home *** CD-ROM | disk | FTP | other *** search
/ Technotools / Technotools (Chestnut CD-ROM)(1993).ISO / lang_c / ctutor2 / video.c < prev    next >
Text File  |  1986-05-27  |  12KB  |  362 lines
  1. /*          VIDEO.C    VIDEO.C    VIDEO.C    VIDEO.C    VIDEO.C
  2.  
  3. VIDEO OUTPUT ROUTINES    X   X  XXX  XXXX   XXXXX   XXX
  4.                          X   X   X   X   X  X      X   X
  5. May 27, 1986             X   X   X   X   X  X      X   X
  6.                           X X    X   X   X  XXX    X   X
  7.                           X X    X   X   X  X      X   X
  8.                            X     X   X   X  X      X   X
  9.                            X    XXX  XXXX   XXXXX   XXX
  10. */
  11. #include "stdio.h"               /* The standard header information */
  12. #include "dos.h"                 /* The DOS register definitions    */
  13. #include "struct.def"            /* The data structures for VC.C    */
  14. char outlist[160];
  15. char strngout[80];
  16. extern struct vars allvars[12];
  17. int bkattr;                      /* background attribute (boxes)    */
  18. int valattr;                     /* values and variables attribute  */
  19. int trnsattr;                    /* transcript attribute            */
  20. int helpattr;                    /* help attribute                  */
  21. int errattr;                     /* error message attribute         */
  22. int vidstart;                    /* start of video memory           */
  23.  
  24. /* ******************************************************** monitor */
  25. /* This function looks at location 0449(hex) in memory to determine */
  26. /* what type of monitor is being used and adjusts the video attri-  */
  27. /* butes accordingly. This allows for flexibility.                  */
  28. monitor()
  29. {
  30. char i[2];
  31. struct SREGS segregs;
  32. unsigned int ds;
  33.  
  34.    segread(&segregs);
  35.    ds = segregs.ds;
  36.    movedata(0,0x449,ds,i,1);     /* get monitor mode from 0000:0449 */
  37.    if (i[0] == 7) {                    /* monochrome monitor in use */
  38.       bkattr = 7;
  39.       valattr = 7;
  40.       trnsattr = 7;
  41.       helpattr = 7;
  42.       errattr = 7;
  43.       vidstart = 0XB000;
  44.    }
  45.    else {                                   /* color monitor in use */
  46.       bkattr = 15;                                  /* bright white */
  47.       valattr = 10;                                  /* light green */
  48.       trnsattr = 14;                                      /* yellow */
  49.       helpattr = 10;                                 /* light green */
  50.       errattr = 128 + 12;                     /* blinking light red */
  51.       vidstart = 0XB800;
  52.    }
  53. }
  54.  
  55. /* ******************************************************* bkgndvid */
  56. /* This routine sets up the data for the double lines used through- */
  57. /* out the background. The codes for the double lines come from the */
  58. /* extended ASCII set. they are actually output to the display by   */
  59. /* the routine "linedisp()".                                        */ 
  60. bkgndvid() 
  61. {
  62. int index;
  63.    for (index = 0;index < 160;++index)
  64.       outlist[index] = bkattr;
  65.    for (index = 2;index <= 156;index += 2)
  66.         outlist[index] = 205;
  67.    outlist[0] = 201;
  68.    outlist[44] = 203;
  69.    outlist[110] = 203;
  70.    outlist[158] = 187;
  71.    linedisp(1);                                     /* video line 1 */
  72.    outlist[0] = 204;
  73.    outlist[44] = 202;
  74.    outlist[110] = 202;
  75.    outlist[158] = 185;
  76.    linedisp(8);                                     /* video line 8 */
  77.    outlist[44] = 205;
  78.    outlist[110] = 205;
  79.    linedisp(23);                                   /* video line 23 */
  80.    outlist[0] = 200;
  81.    outlist[158] = 188;
  82.    linedisp(25);                                   /* video line 25 */
  83.    for (index = 2;index <= 156;index += 2)
  84.       outlist[index] = 32;
  85.    outlist[0] = 186;
  86.    outlist[158] = 186;
  87.    linedisp(24);                                   /* video line 24 */
  88.    for (index = 9;index <= 22;++index)
  89.       linedisp(index);                       /* video lines 9 to 22 */
  90.    outlist[44] = 186;
  91.    outlist[110] = 186;
  92.    for (index = 2;index <= 7;++index)
  93.       linedisp(index);                        /* video lines 2 to 7 */
  94. }
  95.  
  96. /* ******************************************************* valusvid */
  97. /* This routine actually outputs the calculated data to the monitor.*/
  98. /* It outputs all values every time it is called, even if only a few*/
  99. /* values are changed. It is therefore somewhat inefficient.        */
  100. valusvid()
  101. {
  102. long int temp;
  103.    sprintf(strngout,"     A = %12.6f",allvars[0].value);
  104.    strngout[21] = 0;
  105.    strngdis(1,1,valattr);
  106.    sprintf(strngout,"     B = %12.6f",allvars[1].value);
  107.    strngout[21] = 0;
  108.    strngdis(2,1,valattr);
  109.    sprintf(strngout,"     C = %12.6f",allvars[2].value);
  110.    strngout[21] = 0;
  111.    strngdis(3,1,valattr);
  112.    sprintf(strngout,"     D = %12.6f",allvars[3].value);
  113.    strngout[21] = 0;
  114.    strngdis(4,1,valattr);
  115.    sprintf(strngout,"     E = %12.6f",allvars[4].value);
  116.    strngout[21] = 0;
  117.    strngdis(5,1,valattr);
  118.    sprintf(strngout,"     F = %12.6f",allvars[5].value);
  119.    strngout[21] = 0;
  120.    strngdis(6,1,valattr);
  121.  
  122.    temp = allvars[6].value;
  123.    temp = temp & 077777777;
  124.    allvars[6].value = temp;
  125.    sprintf(strngout,"I = %8ld = %8lo = %6lx",temp,temp,temp);
  126.    strngdis(1,23,valattr);
  127.    temp = allvars[7].value;
  128.    temp = temp & 077777777;
  129.    allvars[7].value = temp;
  130.    sprintf(strngout,"J = %8ld = %8lo = %6lx",temp,temp,temp);
  131.    strngdis(2,23,valattr);
  132.    temp = allvars[8].value;
  133.    temp = temp & 077777777;
  134.    allvars[8].value = temp;
  135.    sprintf(strngout,"K = %8ld = %8lo = %6lx",temp,temp,temp);
  136.    strngdis(3,23,valattr);
  137.    temp = allvars[9].value;
  138.    temp = temp & 077777777;
  139.    allvars[9].value = temp;
  140.    sprintf(strngout,"L = %8ld = %8lo = %6lx",temp,temp,temp);
  141.    strngdis(4,23,valattr);
  142.    temp = allvars[10].value;
  143.    temp = temp & 077777777;
  144.    allvars[10].value = temp;
  145.    sprintf(strngout,"M = %8ld = %8lo = %6lx",temp,temp,temp);
  146.    strngdis(5,23,valattr);
  147.    temp = allvars[11].value; 
  148.    temp = temp & 077777777;
  149.    allvars[11].value = temp;
  150.    sprintf(strngout,"N = %8ld = %8lo = %6lx",temp,temp,temp);
  151.    strngdis(6,23,valattr);
  152.  
  153.    strcpy(strngout,"Function Keys --------");
  154.    strngdis(1,56,helpattr);
  155.    strcpy(strngout,"F1-Help-M   F2-Help-S  ");
  156.    strngdis(2,56,helpattr);
  157.    strcpy(strngout,"F3-Print    F4-Mark    ");
  158.    strngdis(3,56,helpattr);
  159.    strcpy(strngout,"F5-Store    F6-Retrieve");
  160.    strngdis(4,56,helpattr);
  161.    strcpy(strngout,"F7-         F8-        ");
  162.    strngdis(5,56,helpattr);
  163.    strcpy(strngout,"F9-Edit     F10-Quit   ");
  164.    strngdis(6,56,helpattr);
  165. }
  166.  
  167. /* ********************************************************* disnew */
  168. /* This routine displays the changed variable only.                 */
  169. disnew(varinuse)
  170. int varinuse;
  171. {
  172. long int temp;
  173. double xx;
  174.  
  175.    if (varinuse < 6) {                       /* display A through F */
  176.       xx = allvars[varinuse].value;
  177.       if (xx < 0.0) xx = -xx;
  178.       if ((xx> 9999999.0) || (xx < .001))
  179.          sprintf(strngout,"%12.5e",allvars[varinuse].value);
  180.       else
  181.          sprintf(strngout,"%12.6f",allvars[varinuse].value);
  182.       strngout[12] = 0;
  183.       strngdis(1+varinuse,10,valattr);
  184.    }
  185.    else {                                    /* display I through N */
  186.       temp = allvars[varinuse].value;
  187.       temp = temp & 077777777;
  188.       allvars[varinuse].value = temp;
  189.       sprintf(strngout,"%8ld = %8lo = %6lx",temp,temp,temp);
  190.       strngdis(varinuse-5,27,valattr);
  191.    }
  192. }
  193.  
  194. /* ********************************************************** helpm */
  195. /* This outputs the math helps to the monitor.                      */
  196. helpm()
  197. {
  198. strtrans(" ",0);
  199. strtrans("$                Help - Mathematics",0);
  200. strtrans("$   All calculations are done in floating point, then",0);
  201. strtrans("$  converted to fixed point for variables I to N.",0);
  202. strtrans("$     Available    ABS()   SQRT()  EXP()   LOG()",0);
  203. strtrans("$     Functions    SIN()   COS()   ATAN()  FACT()",0);
  204. strtrans("$   Nesting is allowable to any depth, but the line",0);
  205. strtrans("$  length is limited to 62 characters.",0);
  206. }
  207.  
  208. /* ********************************************************** helps */
  209. /* This outputs the system helps to the monitor.                    */
  210. helps()
  211. {
  212. strtrans(" ",0);
  213. strtrans("$                   Help - System",0);
  214. strtrans("$  Arrow - selected line   ;   Star - marked line",0);
  215. strtrans("$  F3-Toggle print mode to print all input lines",0);
  216. strtrans("$  F4-Toggle the mark indicator on selected line",0);
  217. strtrans("$  F5-Store all marked lines to a file",0);
  218. strtrans("$  F6-Retrieve a file and calculate while inputting",0);
  219. strtrans("$  F9-Load selected line into input window",0);
  220. strtrans("$  up/down-Move selector up/down 1 line",0);
  221. strtrans("$  Pgup/Pgdn-Move selector up/down 8 lines",0);
  222. }
  223.  
  224. /* ******************************************************* linedisp */
  225. /* This outputs a complete line with attributes already in place.   */
  226. linedisp(line)
  227. int line;
  228. {
  229. struct SREGS segregs;
  230. unsigned int ds;
  231.  
  232.    segread(&segregs);
  233.    ds = segregs.ds;
  234.    movedata(ds,outlist,vidstart,160*(line-1),160);
  235. }
  236.  
  237. /* ******************************************************* strngdis */
  238. /* This outputs a part of a line to the monitor, but first it adds  */
  239. /* the attribute bytes between each of the character bytes.         */
  240. strngdis(row,col,attr)
  241. int row,col;
  242. int attr;
  243. {
  244. int i = 0;
  245. int j = 0;
  246. struct SREGS segregs;
  247. unsigned int ds;
  248.  
  249.    segread(&segregs);
  250.    ds = segregs.ds;
  251.  
  252.    while (strngout[i] && j <= 160) {
  253.       outlist[j] = strngout[i];
  254.       outlist[j+1] = attr;
  255.       j += 2;
  256.       i++;
  257.    }
  258.    movedata(ds,outlist,vidstart,160*row + 2*col,j);
  259. }
  260.  
  261. /* ******************************************************* blnkline */
  262. /* This routine outputs blanks from here to column 79.              */
  263. blnkline(row,col)
  264. int row,col;
  265. {
  266. int i,j,number;
  267. struct SREGS segregs;
  268. unsigned int ds;
  269.  
  270.    segread(&segregs);
  271.    ds = segregs.ds;
  272.    number = 78 - col;
  273.    j = 0;
  274.    for (i = 0;i <= number;++i){
  275.       outlist[j] = ' ';
  276.       outlist[j+1] = trnsattr;
  277.       j += 2;
  278.    }   
  279.   movedata(ds,outlist,vidstart,160*row + 2*col,2*number);
  280. }
  281.  
  282. /* ******************************************************** chardis */
  283. /* This function outputs one character anywhere on the screen.      */
  284. chardis(row,col,attr,ch)
  285. int row,col,attr;
  286. int ch;
  287. {
  288. struct SREGS segregs;
  289. unsigned int ds;
  290.  
  291.    segread(&segregs);
  292.    ds = segregs.ds;
  293.    outlist[0] = ch;
  294.    outlist[1] = attr;
  295.    movedata(ds,outlist,vidstart,160*row + 2*col,2);
  296. }
  297.  
  298. /* ********************************************************* errdis */
  299. /* This function displays the error message with the blinking       */
  300. /* attribute.                                                       */ 
  301. errdis(str)
  302. char str[];
  303. {
  304. int row = 21,col = 50;
  305. int i;
  306. struct SREGS segregs;
  307. unsigned int ds;
  308.  
  309.    segread(&segregs);
  310.    ds = segregs.ds;
  311.    for (i = 0;i <= 24;++i) {
  312.       outlist[2*i] = str[i];
  313.       outlist[2*i+1] = errattr;
  314.    }
  315.    movedata(ds,outlist,vidstart,160*row + 2*col,50);
  316. }
  317.  
  318. /* ******************************************************** clrscrn */
  319. /* This function clears the screen.                                 */
  320. clrscrn()
  321. {
  322. int row,col;
  323.  
  324.    for (row = 0;row < 25;++row)
  325.    for (col = 0;col < 80;++col)
  326.       chardis(row,col,7,' ');
  327. }
  328.  
  329. /* ******************************************************** poscurs */
  330. /* This function positions the cursor anywhere on the screen. It    */
  331. /* calls the DOS function call 10, the video interrupt.             */
  332. poscurs(row,col)
  333. int row,col;
  334. {
  335. int flags;
  336. union REGS inregs;
  337. union REGS outregs;
  338.  
  339.    inregs.h.ah = 2;
  340.    inregs.h.dh = row;
  341.    inregs.h.dl = col;
  342.    inregs.h.bh = 0;
  343.    flags = int86(0x10,&inregs,&outregs);
  344. }
  345.  
  346. /* ******************************************************* prtprblm */
  347. /* This function checks the printer to see if it is turned on and on*/
  348. /* line. It returns a 1 if a problem, 0 if all is OK.               */
  349. prtprblm()
  350. {
  351. union REGS inregs;
  352. union REGS outregs;
  353.  
  354.    inregs.h.ah = 2;
  355.    inregs.x.dx = 0;
  356.    int86(0x17,&inregs,&outregs);
  357.    if ((outregs.h.ah & 0X80) == 0X80)
  358.       return(0);
  359.    else
  360.       return(1);
  361. }
  362.